home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / net / mac / socktst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-20  |  8.6 KB  |  406 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include "sock.hpp"
  5. //#include "tcpip.hpp"
  6. #include "atalk.hpp"
  7.  
  8. atalk_protocol atalk;
  9.  
  10. char delim[]=" \n";
  11. char spinchar[] = "\\|/-";
  12.  
  13. net_protocol *prot = net_protocol::first;
  14. net_socket::socket_type socktype;
  15. net_address *addr;
  16. int port = 0x9091;
  17. int notify_port = 0x9099;
  18.  
  19. void spin()
  20. //{{{
  21. {
  22.     return ;
  23.     
  24.   static int pos = 0;
  25.   
  26.   printf("\r%c",spinchar[pos]);
  27.   pos = (pos+1)&3;
  28. }
  29. //}}}
  30.  
  31. #define MAX_CLIENTS 2
  32.  
  33. void udp_server()
  34. //{{{
  35. {
  36.   net_socket *srv;
  37.   int cont;
  38.  
  39.   // Create listen socket to accept client connections
  40.   printf("Starting server listen socket on port %d.\n",port);
  41.   srv = prot->create_listen_socket(port, socktype);
  42.   srv->read_selectable();
  43.   prot->start_notify(notify_port,"Test server",11);
  44.   printf("Waiting for connections\n");
  45.  
  46.   cont = 1;
  47.   while (cont) {
  48.     spin();
  49.     // wait for next network event
  50.     if (prot->select(0)) {
  51.       if (srv->ready_to_read()) {
  52.         // server socket has data
  53.                 char buf[513];
  54.                 int len;
  55.         net_address *addr;
  56.         char name[80];
  57.  
  58.                 len = srv->read(buf,512,&addr);
  59.                 if (addr)
  60.                     addr->store_string(name,80);
  61.                 else
  62.                     name[0] = 0;
  63.  
  64.                 if (len>0) {
  65.                     buf[len] = 0;
  66.                     printf("Server: Got [%s] from [%s]\n",buf,name);
  67.                 }
  68.  
  69.                 if (addr && len>0) {
  70.                     if (strcmp(buf,"die")==0)
  71.                         cont = 0;
  72.  
  73.                     srv->write(buf,len,addr);
  74.                     printf("Server: Echoing [%s] to [%s]\n",buf,name);
  75.                 }
  76.       }
  77.     }
  78.   }
  79.   delete srv;
  80. }
  81. //}}}
  82.  
  83. void tcp_server()
  84. //{{{
  85. {
  86.   net_socket *srv;
  87.   net_socket *clt[MAX_CLIENTS] = {0,0};
  88.   int state[MAX_CLIENTS] = {0,0};
  89.   char buf[MAX_CLIENTS][256];
  90.   int len[MAX_CLIENTS];
  91.   int cont;
  92.  
  93.   // Create listen socket to accept client connections
  94.   printf("Starting server listen socket.\n");
  95.   srv = prot->create_listen_socket(port, socktype);
  96.   srv->read_selectable();
  97.   prot->start_notify(notify_port,"Test server",11);
  98.   printf("Waiting for connections\n");
  99.  
  100.   cont = 1;
  101.   while (cont) {
  102.     spin();
  103.     // wait for next network event
  104.     if (prot->select(0)) {
  105.       //{{{ Check server socket
  106.       if (srv->ready_to_read()) {
  107.         // server socket has data, i.e. connection requested
  108.         int i;
  109.         net_address *addr;
  110.         net_socket *new_clt;
  111.         char name[80];
  112.       
  113.         new_clt = srv->accept(addr);
  114.         addr->store_string(name,80);
  115.         printf("Got connect from [%s]...",name);
  116.       
  117.         // search for available client storage
  118.         for (i=0; i<MAX_CLIENTS; i++)
  119.           if (clt[i] == 0)
  120.             break;
  121.       
  122.         if (i<MAX_CLIENTS) {
  123.           // save socket to client
  124.           clt[i] = new_clt;
  125.       
  126.           // make reads "selectable" to alert of read events
  127.           new_clt->read_selectable();
  128.           printf("accepted\n");
  129.         }
  130.         else
  131.           printf("rejected!\n");
  132.       }
  133.       //}}}
  134.       //{{{ Check client statuses
  135.       for (int i=0; i<MAX_CLIENTS; i++)
  136.           if (clt[i]) {
  137.             if (clt[i]->error()) {
  138.               printf("Aiieeee!  Error on %d.\n",i);
  139.               delete clt[i];
  140.               clt[i] = 0;
  141.             }
  142.             if (clt[i]->ready_to_read()) {
  143.               // Client sent us data
  144.               if (state[i] == 0) {
  145.                 len[i] = clt[i]->read(buf[i], 256);
  146.                 if (len[i] <= 0) {
  147.                   // 0 length read means EOF
  148.                   printf("Closing connection %i\n",i);
  149.                   delete clt[i];
  150.                   clt[i] = 0;
  151.                   break;
  152.                 }
  153.                 else {
  154.                   // normal read
  155.                   clt[i]->write_selectable();
  156.                   clt[i]->read_unselectable();
  157.                   state[i] = 1;
  158.                   buf[i][len[i]] = 0;
  159.                   printf("Server: From %d Got [%s] len %d\n",i,buf[i],len[i]);
  160.                   if (!strcmp(buf[i],"die"))
  161.                     cont = 0;
  162.                 }
  163.               }
  164.             }
  165.             if (clt[i]->ready_to_write()) {
  166.               if (state[i] == 1) {
  167.                 // Echo data back to client
  168.                 clt[i]->write(buf[i], len[i]);
  169.                 clt[i]->read_selectable();
  170.                 clt[i]->write_unselectable();
  171.                 state[i] = 0;
  172.                 printf("Server: Echoed to %d: [%s] len %d\n",i,buf[i],len[i]);
  173.               }
  174.             }
  175.           }
  176.       //}}}
  177.     }
  178.   }
  179.   for (int i=0; i<MAX_CLIENTS; i++)
  180.     if (clt[i])
  181.       delete clt[i];
  182.   delete srv;
  183. }
  184. //}}}
  185.  
  186. void client()
  187. //{{{
  188. {
  189.   net_socket *clt;
  190.   char s[256];
  191.   int len;
  192.  
  193.   // finding server
  194.     printf("Trying to find server\n");
  195.     net_address *addr;
  196.   while (!(addr = prot->find_address(notify_port,s)))
  197.         spin();
  198.  
  199.   // Create new socket to server
  200. //    addr->set_port(port);
  201.     addr->store_string(s,256);
  202.   printf("Trying to connect to server [%s].\n",s);
  203.     clt = prot->connect_to_server(addr,socktype);
  204.   //  ((unix_fd*)clt)->broadcastable();
  205.   
  206.   while (1) {
  207.     printf("Enter client data.\n");
  208.     gets(s);
  209.  
  210.     // Quit on Q
  211.     if (!strcmp(s,"q"))
  212.       break;
  213.  
  214.     clt->read_unselectable();
  215.     clt->write_selectable();
  216.     while (!clt->ready_to_write() && !clt->error()) {
  217.       spin();
  218.       prot->select(0);
  219.     }
  220.  
  221.     if (clt->error())
  222.       break;
  223.  
  224.     len = clt->write(s,strlen(s));
  225.     
  226.     printf("Wrote [%s] length %d\n",s,len);
  227.     
  228.     clt->read_selectable();
  229.     clt->write_unselectable();
  230.     while (!clt->ready_to_read() && !clt->error()) {
  231.       spin();
  232.       prot->select(0);
  233.     }
  234.     
  235.     if (clt->error())
  236.       break;
  237.     
  238.     len = clt->read(s,256);
  239.  
  240.     if (len <= 0) {
  241.       printf("Server died\n");
  242.       break;
  243.     }
  244.     
  245.     printf("Got [%s] len %d\n",s,len);
  246.   }
  247.   delete clt;
  248. }
  249. //}}}
  250.  
  251. void ShowZones()
  252. {
  253.     int num_zones;
  254.     char **name;
  255.     
  256.     name = atalk.GetZones(num_zones);
  257.     
  258.     printf("Got %d zones.\n",num_zones);
  259.     for (int i=0; i<num_zones; i++)
  260.         printf("  %s\n",name[i]);
  261.         
  262.     char buff[40];
  263.     
  264.     buff[0] = 0;
  265.     atalk.GetMyZone(buff);
  266.  
  267.     printf("In zone: [%s]\n",buff);
  268. }
  269.  
  270. void main()
  271. //{{{
  272. {
  273.   char str[256], *s;
  274.  
  275.   if (prot->installed()) {
  276.     printf("Testing %s...\n",prot->name());
  277.   }
  278.   else {
  279.     printf("No protocol!\n");
  280.     exit(1);
  281.   }
  282.  
  283.   while (1) {
  284.     printf("\n> ");
  285.     gets(str);
  286.     s = strtok(str,delim);
  287.     if (!s)
  288.       break;
  289.  
  290.     switch (s[1]) {
  291.     case 'u':
  292.     case 'U':
  293.       socktype = net_socket::SOCKET_FAST;
  294.       break;
  295.     case 's':
  296.     case 'S':
  297.       socktype = net_socket::SOCKET_SECURE;
  298.       break;
  299.     }
  300.  
  301.     switch (s[0]) {
  302.     case 'c':
  303.     case 'C':
  304.       s = strtok(0,delim);
  305. #if 0
  306.       addr = prot->get_node_address(s,port,0);
  307. #else
  308.  
  309. #if 0
  310.       sockaddr_in host;
  311.       char tmp[4];
  312.       
  313.       for (int i=0; i<4; i++)
  314.       {
  315.         int num = 0;
  316.         while (*s)
  317.         {
  318.           if (*s=='.')
  319.           {
  320.             s++;
  321.             break;
  322.           }
  323.           num = num*10 + *s - '0';
  324.           s++;
  325.         }
  326.         tmp[i] = num;
  327.       }
  328.       
  329.       memset( (char*) &host,0, sizeof(host));
  330.       host.sin_family = AF_INET;
  331.       host.sin_port = htons(port);
  332.       host.sin_addr.s_addr = htonl(INADDR_ANY);
  333.       memcpy(&host.sin_addr,tmp,sizeof(in_addr));
  334.       
  335.       addr = new ip_address(&host);
  336. #else
  337.       AddrBlock host;
  338.       short tmp[3];
  339.       
  340.       for (int i=0; i<4; i++)
  341.       {
  342.         int num = 0;
  343.         while (*s)
  344.         {
  345.           if (*s==':')
  346.           {
  347.             s++;
  348.             break;
  349.           }
  350.           num = num*10 + *s - '0';
  351.           s++;
  352.         }
  353.         tmp[i] = num;
  354.       }
  355.       
  356.       addr = new atalk_address(tmp[0],tmp[1]);
  357.       addr->set_port(tmp[2]);
  358. #endif
  359.  
  360. #endif
  361.       client();
  362.       break;
  363.     case 's':
  364.     case 'S':
  365.             if (socktype == net_socket::SOCKET_FAST)
  366.                 udp_server();
  367.             else
  368.                 tcp_server();
  369.       break;
  370.     case 'z':
  371.         ShowZones();
  372.         break;
  373.     case 'q':
  374.     case 'Q':
  375.       exit(1);
  376.       break;
  377.     case 'h':
  378.     case '?':
  379.         printf(    "Usage:\n"
  380.                         "  su  - start unsecure server\n"
  381.                         "  ss  - start secure server\n"
  382.                         "  cu  - connect to unsecure server\n"
  383.                         "  cs  - connect to secure server\n"
  384.                         "  z   - show zones\n"
  385.                         "  q   - quit\n"
  386.                         "\n"
  387.                         "Note: sending a die message to a server ends the server\n"
  388.                         );
  389.         break;
  390.     }
  391.   }
  392. }
  393. //}}}
  394.  
  395. //{{{ Revision Log
  396. /*//////////////////////////////////////////////////////////////////////
  397. $Log$
  398. //////////////////////////////////////////////////////////////////////*/
  399. //}}}
  400.  
  401. //{{{ Emacs Locals
  402. // Local Variables:
  403. // folded-file: t
  404. // End:
  405. //}}}
  406.